package day11.exercise;


import java.util.*;
import java.util.Map.Entry;

/**
 * 本类用来演示:
 *
 * map->放15个[1,5]之间的随机整数
 *
 * 1. 统计每个随机数出现的次数
 * 2. 根据次数降序排.
 *
 * @author: success
 * @date: 2022/1/19 3:16 下午
 */
public class MapCountDemo {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < 15; i++) {
            int n = (int) (Math.random()*5+1);
            list.add(n);
        }
        System.out.println(list);

        count2(list);
    }

    public static void count2(List<Integer> list){
        Map<Integer,Integer> map = new HashMap<>();

        //遍历list
        for (Integer n : list) {
            //判断这个数字是否在map中出现过
            if(map.containsKey(n)){
                //根据key获取值[次数]
                Integer value = map.get(n);
                //次数+1,替换原来n{key}对应的旧值
                map.put(n, value+1);
            }else{
                map.put(n,1);
            }
        }
        System.out.println(map);

        //map集合的第二种迭代方式 - key-value=>Entry对象
        Set<Map.Entry<Integer,Integer>> set = map.entrySet();
        //set集合不支持排序的
        //set集合中的元素 -> list集合

        List<Entry<Integer,Integer>> sortList = new ArrayList<>();
        Iterator<Map.Entry<Integer,Integer>> iter = set.iterator();
        while(iter.hasNext()){
            Entry<Integer,Integer> e = iter.next();
            sortList.add(e);
        }

        sortList.sort((e1,e2)->{
            return e2.getValue() - e1.getValue();
        });

        for (Entry<Integer, Integer> e : sortList) {
            System.out.println(e.getKey()+"->"+e.getValue());
        }

    }

    /**
     * 使用的是第三方自定义的对象类型 - 通用性
     * @param list
     */
    private static void count(List<Integer> list) {
        Map<Integer,Integer> map = new HashMap<>();

        //遍历list
        for (Integer n : list) {
            //判断这个数字是否在map中出现过
            if(map.containsKey(n)){
                //根据key获取值[次数]
                Integer value = map.get(n);
                //次数+1,替换原来n{key}对应的旧值
                map.put(n, value+1);
            }else{
                map.put(n,1);
            }
        }
        System.out.println(map);

        //排序... List<对象>
        //1. 想办法取出map集合中的所有的key-value - 遍历
        //2. key-value封装到对象中
        //3. 将每个对象放入到list集合中
        //4. list.sort

        List<RandomCount> sortList = new ArrayList<>();

        map.forEach((k,v)->{
            //创建一个自定义的对象
            RandomCount r = new RandomCount(k,v);

            sortList.add(r);
        });

        sortList.sort((r1,r2)->{
            return r2.getValue() - r1.getValue();
        });

        for (RandomCount r : sortList) {
            System.out.println(r.getKey()+"->"+r.getValue());
        }
    }
}